Storage device with SCSI formatting

ABSTRACT

Provided are a method, system, and an article of manufacture for detecting errors while accessing a storage device. A host system writes an identical initialization pattern into each block of a plurality of blocks while formatting the storage device. Each block of the plurality of blocks has a checksum field capable of containing a value. Any host system generates an error when data from a retrieved block from the plurality of blocks computes to a checksum that is different from the value contained within the checksum field for the retrieved block, and the retrieved block does not contain the initialization pattern.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a divisional patent application of U.S. patentapplication Ser. No. 10/055,593, filed on Jan. 22, 2002 and entitled“Error Detection in Storage Data”; the disclosure of which is herebyincorporated herein in its entirety.

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates to a method, system, and an article ofmanufacture for implementing an error detection scheme in storage data.

2. Description of the Related Art

A block addressable storage device is typically comprised of one or moredisks, such as flexible disks, rigid disks, optical discs, and storesdata in addressable groups referred to as blocks. The number of bytes ofdata contained in a single block is called the block length or blocksize. While the block length can be any number of bytes, storage devicemanufacturers often format the storage devices into blocks with a blocklength of 512 bytes. The storage devices can be reformatted into blocksof a different block length. Application programs that read and writedata to the storage devices need assurance that data integrity ismaintained as data is transferred between the storage device andapplication program.

Prior art storage devices include techniques for assuring dataintegrity. For instance, storage device controllers often utilize anerror correcting code (ECC) algorithm to detect and possibly correcthardware related failures within the storage device. In addition tohardware errors, data integrity may be compromised by transport errorsthat occur during data transmission via Small Computer System Interface(SCSI) cables, storage adapter cards and storage device drivers. Failureto detect the transport errors, as well as disk error allows corruptdata to propagate. Undetected transport errors that occur within dataare referred to as “silent data corruption.” Silent data corruptionoccurs when the application program retrieves data from the storagesystem (i.e. a disk read request) that is stale, altered or lost withoutbeing detected or corrected. Stale data is data that was written at anearlier time and is incorrectly returned in place of the more recent(lost) data. Altered data is data that is present but corrupted orchanged and no longer correctly represents the original data. Finally,lost data is data that is lost and no longer available. The presence ofsuch errors is of substantial concern for critical applications wherethe impact of undetected errors can be catastrophic.

In prior art, checksums have been used to detect errors in data. Thechecksum of a group of data items is stored or transmitted with thegroup of data items. The checksum value is calculated by treating thedata items as numeric values. Checksums are widely used in networkprotocols, where a checksum generated from the bits of a messageaccompanies the message during transmission. For instance, many checksumalgorithms perform an XOR of the bits in the message to generate thechecksum. The receiving station then applies the same checksum algorithm(e.g. XOR) to the message and checks to make sure that the computednumerical value is the same as the checksum within the transmission. Inview of the prevalence of silent data corruption, there is a need in theart to provide an improved checksum based technique to detect silentdata corruption.

SUMMARY OF THE PREFERRED EMBODIMENTS

Provided are methods, systems and programs to detect errors whileaccessing a storage device. A host system retrieves one block from aplurality of blocks, wherein a pattern has been written into theplurality of blocks during initialization of the blocks in a storagedevice. The host system determines whether the retrieved block includesthe pattern and also determines whether a checksum computed from theretrieved block is different than the value in a checksum field of theretrieved block. The host system generates an error when data from theretrieved block from the plurality of blocks computes to a checksum thatis different from the value contained within the checksum field for theretrieved block, and the retrieved block does not contain theinitialization pattern.

Still further, the pattern written into the plurality of blocks whileinitializing data in the storage device is written during a formatoperation on the storage device, wherein no checksum value is written tothe checksum field during the format operation.

Further implementations provide a system, method and article ofmanufacture for formatting a storage device into a plurality of blocksof a block size. A set of bits is reserved within each of the pluralityof blocks, to stoke a pattern. A checksum field is reserved within eachof the plurality of blocks, to store a checksum. The storage device isformatted into the plurality of blocks. During the formatting, thepattern is written into the set of bits within each of the plurality ofblocks, wherein no checksum value is written to the checksum fieldduring the formatting.

In one implementation, the formatting comprises executing of a SCSIFORMAT UNIT command. In farther implementations the SCSI FORMAT UNITcommand is configured by a host system and executed by the storagedevice. The implementations provide a checksum based technique that candetect errors.

BRIEF DESCRIPTION OF THE DRAWINGS

Referring now to the drawings in which like reference numbers representcorresponding parts throughout:

FIG. 1 a illustrates the blocks of a storage device in accordance withimplementations of the invention;

FIG. 1 b illustrates the checksum field within a block of a storagedevice in accordance with implementations of the invention;

FIG. 1 c illustrates a disk label within a block of a storage device inaccordance with implementations of the invention;

FIG. 2 illustrates a block diagram of a first computing environment inwhich certain aspects of the invention are implemented;

FIG. 3 illustrates logic to write an initialization pattern when a hostformats a disk in accordance with implementations of the invention;

FIG. 4 illustrates the use of SCSI FORMAT UNIT command in accordancewith implementations of the invention;

FIG. 5 illustrates logic to write to a storage device in accordance withimplementations of the invention; and

FIG. 6 illustrates logic to read from a storage device in accordancewith implementations of the invention.

FIG. 7 illustrates the block diagram of a second computing environmentin which certain implementations of the invention can be implemented.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

In the following description, reference is made to the accompanyingdrawings which form a part hereof and which illustrate severalimplementations. It is understood that other implementations may beutilized and structural and operational changes may be made withoutdeparting from the scope of the present implementations.

Although checksums have been used within storage devices, existingchecksum features within storage devices have limitations. For instance,checksums implemented within the storage device alone cannot detectsilent data corruption which occurs between the storage device and thehost applications. The copending and commonly assigned patentapplication entitled “End-to-End Disk Data Checksumming,” having U.S.patent application Ser. No. 09/917,315 and filed on Jul. 27, 2001,discloses an error detection scheme implemented in a host system todetect errors, such as transmission errors, resulting from silent datacorruption. While writing data to a block of a storage device, the hostcalculates a checksum corresponding to the data and writes the checksuminto the block of storage device. Subsequently, while reading the datafrom the block of the storage device, the host compares a checksumcalculated from the read data to the previously written checksum. If thecalculated checksum does not match the previously written checksum thehost generates a checksum error.

To utilize the error detection scheme described in the patentapplication entitled “End-to-End Disk Data Checksumming,” a host maywrite a checksum to every block of the storage device after formattingthe storage device in order to avoid a checksum error during the firstread after the disk is formatted. The error detection scheme describedin the patent application entitled “End-to-End Disk Data Checksumming”does not allow the host to detect silent data corruption without havingto write the checksum to every block of the storage device afterformatting the storage device. The process of writing the checksum toeach block after formatting the storage device may be time consuming.For this reason, described implementations provide techniques toinitialize the disk for error detection, such as the error detectionschemes disclosed in “End-to-End Disk Data Checksumming.”

FIG. 1 a illustrates a storage device 80 formatted into a plurality of nblocks, 1^(st) block 100 ₁, 2^(nd) block 100 ₂, i^(th) block 100 _(i),n^(th) block 100 _(n). The number of blocks in the storage device 80 canexceed several million or more when the storage device 80 has a largecapacity. The storage device 80 may comprise any storage device known inthe art, such as a single disk drive, a Direct Access Storage Device(DASD), Just a Bunch of Disks (JBOD), a Redundant Array of IndependentDisks (RAID), a tape library, an optical library, and so on.Manufacturers of the storage device 80 often preformat the storagedevice 80 into blocks of block length 512 bytes when shipping thestorage device 80. However, it is possible to reformat the storagedevice 80 into blocks of any size.

FIG. 1 b illustrates the i^(th) block 100 _(i) contained within thestorage device 80. The block 100 _(i) contains data field 110 _(i) and achecksum field 120 _(i). The checksum field 120 _(i) stores a checksumcorresponding to data in data field 110 _(i). In one implementation thechecksum field 120 _(i) is 16 bytes, and the data is 512 bytes giving atotal of 528 bytes for the block length of each block. Each of theblocks 100 ₁, 100 ₂, . . . 100 _(i), . . . , 100 _(n) has the checksumfield 120 _(i) and the data field 110 _(i). In certain implementations,the checksum is comprised of a 32-bit Exclusive-Or (XOR) checksum.However, the checksum can be calculated using any checksumming techniqueknown in the art. The checksum for each block is kept with the data inthe same block rather than in a separate location on the storage device80. In alternative implementations, the checksum for each block can bekept in a separate location on the storage device 80 or on a differentstorage device.

FIG. 1 c illustrates the disk label 84 within the first block 100 _(i)of a storage device in accordance with implementations of the invention.A disk label 84 is part of the data field 110 ₁ on the first block 100 ₁of the storage device 80, and the disk label 84 identifies the storagedevice 80. The disk label 84 also contains a checksumming flag 85. Thechecksumming flag 85 indicates whether the storage device 80 containschecksums.

FIG. 2 illustrates a computing environment for the implementation. Ahost system 2 includes an operating system 4 (the operating systemincludes device drivers) and is capable of executing multipleapplication programs 6 a, 6 b, 6 c. The host 2 may comprise anycomputational device known in the art including a server class machine,a mainframe, a desktop computer, a laptop computer, a hand heldcomputer, a telephony device. The operating system 4 may comprise anyoperating system known in the art capable of concurrently executingmultiple application programs 6 a, 6 b, 6 c and concurrently generatingI/O requests. Although multiple applications can be executed on the host2, only three application programs 6 a, 6 b, 6 c are shown forillustration purposes. The applications can be any applications known inthe art. The host system 2 further includes a target driver 10, twostorage device drivers 24 and 26, and storage adapter cards 12 and 14. Aformat utility 30 is also present within host system 2. The formatutility 30 can be used by the host system 2 to format storage devices(e.g. the storage device 80, or storage device 82). Alternatively, thecode for the format utility 30 can be stored in a separate storage unitor run from a command prompt (e.g. UNIX shell prompt) manually from thehost system 2, or can be run from any other system connected to thestorage devices 80 and 82. Although two storage devices 80, 82 areshown, the host system 2 may communicate with only one or more than twostorage devices.

The application programs 6 a, 6 b, 6 c generate (I/O) requests to thetwo storage devices 80 and 82 (there may be additional storage devices),where the data files used by the application programs 6 a, 6 b, 6 c arestored. In certain implementations, to coordinate the I/O process, allI/O requests are transferred from the application programs 6 a, 6 b, 6 cto a single target driver 10 for communicating with multiple storagedevice drivers 24 and 26. The target driver 10 includes code to process,generate and verify checksum values. If an I/O request is for storagedevice 80, the target driver 10 determines which blocks within storagedevice 80 should be accessed to read/write the data used by theapplications 6 a, 6 b, 6 c. In addition, the target driver 10 adds achecksum to the data blocks on the write function and subtracts thechecksum on the read function, which will be explained in greater detailwith respect to FIGS. 5 and 6. The target driver 10 can communicate withthe storage devices 80, 82 through the storage device drivers 24, 26 andthe storage adapter cards 12, 14 in, for example, any of a number ofways known to those of ordinary skill in the art.

The target driver 10 generates generic device commands in response toI/O requests from the applications 6 a, 6 b, 6 c. The generic devicecommands are converted to device specific commands by the storagedrivers 24 and 26. In certain implementations, the target driver 10handles all the checksumming and error detection operations, therebyavoiding the need to modify the storage device drivers 24 and 26, whichare typically supplied by the manufacturers of the corresponding storagedevices. However, in alternative implementations, operations describedas performed by the target driver can be performed by the storage devicedrivers.

FIG. 3 illustrates logic implemented in the target driver 10 to formatand write initialization patterns in a single pass through the storagedevice 80 when the host 2 formats the storage device 80 in accordancewith an implementation of the invention. Control begins with the host 2reading (at block 400) the information related to the storage device 80where the storage device 80 has been formatted into 512 byte blocks. Theinformation related to the storage device 80 may be kept either withinthe storage device 80 or in various configuration files within host 2.The various configuration files may be created when the storage device80 and the storage adapter card 12 are attached to the host 2, and thehost 2 installs the storage device driver 24. At block 405, the host 2determines an initialization pattern to be written in every block of thestorage device 80.The initialization pattern is stored in a sequence ofbits. A FOR loop begins at block 410 and extends to block 420. At block410, the block number i is incremented from 1 to the number of blocks,n, at every loop of the FOR loop. At the conclusion of block 410, thehost executes block 415 a and 415 b in a single operation. Alternativelythe host may execute block 415 a and then immediately execute block 415b. At block 415 a, host 2 formats block i into 528 bytes. At block 415b, the host 2 writes the initialization pattern onto block i. At theconclusion of blocks 415 a and 415 b, control passes (at block 420) tothe end of the FOR loop and control passes back to block 410. After thehost 2 formats and writes the initialization pattern on block n of thestorage device 80, control passes to block 425, where the host 2modifies the disk label 84 by writing information pertaining to theinitialization pattern on storage device 80. The host 2 also sets thechecksumming flag 85 on disk label 84, to indicate that the disk mayoperate as a checksummed disk. Host 2 may modify the process of FIG. 3for different storage devices and storage device drivers. Themodifications may depend on the particular specifications of the storagedevice 80. The particular specifications may depend on the industrystandard the storage device 80 supports, or may be proprietary tostorage device 80.

FIG. 4 illustrates various data structures associated with the FORMATUNIT command 450 specified in the Small Computer System Interface 3(SCSI-3) specification in accordance with implementations of theinvention. The FORMAT UNIT command 450 includes data structures that areused to provide an initialization pattern for use when formatting theblocks. Certain implementations use the FORMAT UNIT command 450 of theSCSI-3 specification to format and write initialization patterns in asingle pass through the storage device 80 (as described in FIG. 3).Further details of the FORMAT UNIT command 450 are described in thepublication entitled “Information Technology—SCSI-3 Block Commands” byAmerican National Standards Institute, Inc. (revision 8c, published on13 Nov. 1997; also available as technical report/standard NCITS306:1998), which publication is incorporated herein by reference in itsentirety.

FIG. 4 shows the FORMAT UNIT COMMAND 450 having the FMTDATA 452 field,and other fields. In certain implementations, the host 2 sets theFMTDATA 452 field to one. When the FMTDATA field is set to one, anyprogram that interprets the FORMAT UNIT COMMAND looks for the FORMATUNIT parameter list 454. The FORMAT UNIT parameter list 454 starts withthe DEFECT LIST HEADER 456. The host 2 sets the IP 462 field to one inthe DEFECT LIST HEADER 456. When the IP 462 field is set to one, anyprogram that interprets the FORMAT UNIT COMMAND 450 looks for theINITIALIZATION PATTERN DESCRIPTOR field 458. In the INITIALIZATIONPATTERN DESCRIPTOR field 458, the host 2 sets the IP MODIFIER 466 fieldto be zero, the INITIALIZATION PATTERN LENGTH 470 field to the number ofbytes in the initialization pattern, the INITIALIZATION PATTERN 472field to a pattern, and the PATTERN TYPE 468 field to be one to fill thepattern repeatedly within the number of bytes in the initializationpattern. For example, if the pattern is hexadecimal 5A3C and there areeight bytes in the initialization pattern, then the initializationpattern is hexadecimal 5A3C5A3C5A3C5A3C.

FIG. 5 illustrates logic in the host 2 to write to the storage device 80in accordance with implementations of the invention. Control begins atblock 600 when the target driver 10 receives a write request from oneapplication 6 a, 6 b, 6 c. Since most storage device drivers manipulatedata in 512 byte sized blocks, the write request is processed in thetarget driver 10 in data blocks of 512-bytes. Before target driver 10performs the write function, the target driver 10 first checks thechecksumming flag 85 on the disk label 84 and determines (at block 602)whether checksumming is enabled for the storage device 80. If thestorage device 80 does not have checksumming enabled, then the checksumoperation cannot be performed and the write request is sent (at block606) to the storage device 80 via the storage adapter card 12 and thestorage device driver 24 without using the checksum algorithm. However,if the storage device 80 has checksumming enabled, the target driver 10(at block 604) allocates memory and computes a checksum corresponding tothe 512 byte data blocks of the write request. The checksum is thenstored with the write data to increase the data size of the write datablock up to 528-bytes. At block 606, the 528 byte data block (with thechecksum included) is then sent to the storage device driver 24, whichcommunicates directly with the storage adapter card 12. The storagedevice driver 24 instructs (at block 608) the storage adapter card 12 towrite the data block with the checksum onto storage device 80 at thelocation determined by the target driver 10 in a manner known in theart.

FIG. 6 illustrates logic in host 2 to read from a storage device inaccordance with the implementation. Control begins at block 700 when thetarget driver 10 receives a read request from one application 6 a, 6 b,6 c. Upon identifying the read request, the target driver 10 locates theaddress where the data blocks are stored on the storage device 80. Thetarget driver 10 then sends the location of the requested data blocks tothe storage device driver 24, and the storage device driver 24 retrieves(at block 702) the data blocks from the storage device 80 through thestorage adapter card 12 in a manner known in the art.

At block 704, the target driver 10 determines whether the retrieved datablock has incorporated the checksum feature by reading the checksummingflag 85 on the disk label 84. If the checksumming flag 85 indicates thatchecksumming is not enabled for this device, then the target driver 10will understand that the checksum feature was not added during the writefunction, and the checksum algorithm will not be used. In such case, theretrieved data blocks are sent (at block 714) to the application program6 a, 6 b, or 6 c in a manner known in the art. However, if checksum isenabled, the target driver 10 will use the checksum algorithm. Thus, incertain implementations the same target driver 10 can be used in astorage device 80 using 512-byte unchecksummed disk blocks or 528-bytechecksummed disk blocks. At block 706, the target driver 10 calculatesthe checksum associated with the retrieved data block. At block 708, acompare function is performed between the calculated checksum and thechecksum contained within checksum field 120 _(i) of the retrieved datablock. The compare operator will return a value of “true” only if bothvalues are the same. If a “true” value is returned, then the targetdriver 10 (at block 712) strips away the checksum from the read data todecrease the data size of the write data block from 528-bytes to512-bytes.

At block 714, the data blocks are sent to the application program 6 a, 6b, or 6 c in the format that the application program 6 a, 6 b, or 6 ccan read (i.e. 512-byte disk blocks). If a “false” value is returned atblock 708, the target driver 10 determines whether the block of data wasread from a block that has not been written to before. In block 710, thetarget driver 10 determines whether the initialization pattern ispresent on the block of data 100 _(i). If the initialization patternoccupies all the bytes of the data field 110 _(i) on the block of data100 _(i), then control proceeds to block 712 to remove the checksum andreturn the data, which in this case is just the initialization pattern.In alternative implementations where the initialization pattern is kepton some of the bytes of the data field 110 _(i) of the block of data 100_(i), the initialization pattern may be removed before returning thedata. In other alternative implementations where the initializationpattern is kept in the checksum field 120 _(i), the checksum field 120_(i) may be removed before returning the data. If in block 710, theinitialization pattern is absent on the block of data 110 _(i), then thetarget driver 10 concludes that an incorrect data block was returned orthat the data was corrupt. At block 718, an error message is sent to theapplication program 6 a, 6 b, or 6 c, notifying that an error wasdetected during the read request.

Including the checksum program at the host or driver level, versuswithin the disk drive or storage device enclosure, allows detection ofsilent data corruption that occurs between the disk drive and the host.As stated, silent data corruption may result from transport errorsoccurring in the SCSI cables, storage driver adapters, storage devicedrivers, etc. By placing the checksum routine at the host or driverlevel, silent data corruption occurring upstream from the disk drive isdetected. In addition, locating the checksum routine at the host ordriver level implements the checksum independent of the hardware. Noadditional hardware is required to perform the checksum function.Instead, a software update can be performed to an existing host systemto install an updated target driver containing the checksum program.Furthermore, keeping the checksum function at the host or driver levelallows the checksum to remain functionally transparent to users,operating without affecting existing applications on the host system orrequiring updates or modifications to host system applications.

FIG. 7 illustrates another implementation where in addition to the host2 there is another host 2 a and a server 2 b. The server 2 b can be anycomputational device known in the art. The hosts 2 and 2 a and theserver 2 b are connected to the storage devices 80 and 82 via a network3. The server 2 b formats and writes the initialization pattern on thestorage devices 80 and 82. Subsequently, the host systems 2 and 2 a andoptionally the server 2 b, read from and write to the storage devices 80and 82. FIG. 7 illustrates the situation where one computational deviceformats the storage devices and subsequently a plurality ofcomputational devices perform read and write operations with respect tothe storage devices 80 and 82. The servers 2, 2 a, 2 b all include thetarget driver 10 and perform the operations described in FIGS. 5 and 6.In one implementation, the storage devices 80 and 82 may be part of astorage area network geographically distant from the location of thehost systems 2 and 2 a. Similarly, the server 2 b may be geographicallydistant from the location of the host systems 2 and 2 a.

Additional Implementation Details

The described error detection techniques may be implemented as a method,apparatus or article of manufacture using standard programming and/orengineering techniques to produce software, firmware, hardware, or anycombination thereof. The term “article of manufacture” as used hereinrefers to code or logic implemented in hardware logic (e.g., anintegrated circuit chip, Programmable Gate Array (PGA), ApplicationSpecific Integrated Circuit (ASIC), etc.) or a computer readable mediumsuch as, magnetic storage medium (e.g. hard disk drives, floppy disks,tape), optical storage (e.g., CD-ROMs, optical disks, etc.), volatileand non-volatile memory devices (e.g., EEPROMs, ROMs, PROMs, RAMs,DRAMs, SRAMs, firmware, programmable logic, etc.). Code in the computerreadable medium is accessed and executed by a processor. Of course,those skilled in the art will recognize that many modifications may bemade to this configuration without departing from the scope of theimplementations, and that the article of manufacture may comprise anyinformation bearing medium known in the art.

The described implementations show the host both formatting the storagedevices as well as reading and writing to the storage devices. Thedescribed implementations provided a technique for managing the flow ofI/Os to a device driver for a storage device. A 32-bit XOR algorithm wasused for checksumming. Alternatively, other algorithms can be used forchecksumming which will compare the checksum of the retrieved data withthe requested data, such as the Fletcher32-p algorithm. In addition, thechecksum was described with a certain number of bytes of information.Alternatively, the storage device can be reformatted to any other diskblock length to increase or decrease the disk block length toaccommodate different checksum sizes and data blocks. For example, a520-byte block size maybe used instead of a 528-byte data block. Inaddition, in the described implementations, the determination of whetherthe checksum feature was enabled on the storage device was made bychecking the checksumming flag on the disk label. Additionally, adetermination of whether the checksum feature is enabled can beperformed by checking the size of the data blocks in the storage devicewithout the use of the checksumming flag.

In the described implementations, the checksumming feature was performedby the target driver. Alternatively, a checksumming driver could just belayered on top of any of the current I/O driver stacks or implemented inanother layer of the I/O subsystem. In addition, the code of the targetdriver 10 is described as excluding the device driver code for thestorage device. Alternatively, the target driver may include the codefor one or more device drivers.

The preferred logic of FIGS. 3, 5 and 6 described specific operationsoccurring in a particular order. Further, the steps may be performed inparallel as well as sequentially. In alternative embodiments, certain ofthe logic operations may be performed in a different order, modified orremoved and still implement preferred embodiments of the presentinvention. Morever, steps may be added to the above described logic andstill conform to the preferred embodiments.

Therefore, the foregoing description of the implementations has beenpresented for the purposes of illustration and description It is notintended to be exhaustive or to limit the invention to the precise formdisclosed. Many modifications and variations are possible in light ofthe above teaching. It is intended that the scope of the invention belimited not by this detailed description, but rather by the claimsappended hereto. The above specification, examples and data provide acomplete description of the manufacture and use of the composition ofthe invention. Since many embodiments of the invention can be madewithout departing from the spirit and scope of the invention, theinvention resides in the claims hereinafter appended.

1. A method for formatting a storage device into a plurality of blocksof a block size, comprising: reserving a set of bits within each of theplurality of blocks to store a pattern; reserving a checksum fieldwithin each of the plurality of blocks to store a checksum; formattingthe storage device into the plurality of blocks; and during theformatting, writing the pattern into the set of bits within each of theplurality of blocks, wherein no checksum value is written to thechecksum field during the formatting; wherein the formatting comprisesexecuting a SCSI FORMAT UNIT command, further comprising: setting aFMTDATA field in the FORMAT UNIT command field within data structures ofthe FORMAT UNIT command; setting an IP field in a DEFECT LIST HEADERfield within the data structures of the FORMAT UNIT command; setting aPATTERN TYPE to be hexadecimal 01 in an INITIALIZATION PATTERNDESCRIPTOR field within the data structures of the FORMAT UNIT command;and setting an INITIALIZATION PATTERN LENGTH and an INITIALIZATIONPATTERN field in the INITIALIZATION PATTERN DESCRIPTOR field within thedata structures of the FORMAT UNIT command.
 2. The method of claim 1,where the checksum field occupies the same location as the set of bitswithin each of the plurality of plurality of blocks.
 3. The method ofclaim 1, wherein the pattern and checksum field are at identicallocations in each of the plurality of blocks.
 4. The method of claim 1,wherein the block size on the storage device is increased as a result ofstoring the checksum.
 5. The method of claim 1, wherein the SCSI FORMATUNIT command is configured by a host system and executed by the storagedevice.
 6. The method of claim 1, wherein the storage device is a memberof a set of storage devices comprising a Direct Access Storage Device(DASD), Just a Bunch of Disks (JBOD), a Redundant Array of IndependentDisks (RAID), a flexible disk, a rigid disk, a tape library and anoptical library.
 7. A system for formatting a storage device into aplurality of blocks of a block size, comprising: means for reserving aset of bits within each of the plurality of blocks to store a pattern;means for reserving a checksum field within each of the plurality ofblocks to store a checksum; means for formatting the storage device intothe plurality of blocks; and during the formatting, means for writingthe pattern into the set of bits within each of the plurality of blocks,wherein no checksum value is written to the checksum field during theformatting; wherein the means for formatting comprises executing a SCSIFORMAT UNIT command, wherein the executing further comprises: setting aFMTDATA field in the FORMAT UNIT command field within data structures ofthe FORMAT UNIT command; setting an IP field in a DEFECT LIST HEADERfield within the data structures of the FORMAT UNIT command; setting aPATTERN TYPE to be hexadecimal 01 in an INITIALIZATION PATTERNDESCRIPTOR field within the data structures of the FORMAT UNIT command;and setting an INITIALIZATION PATTERN LENGTH and an INITIALIZATIONPATTERN field in the INITIALIZATION PATTERN DESCRIPTOR field within thedata structures of the FORMAT UNIT command.
 8. An article of manufactureincluding code for formatting a storage device into a plurality ofblocks of a block size, wherein the code causes operations to beperformed, the operations comprising: reserving a set of bits withineach of the plurality of blocks to store a pattern; reserving a checksumfield within each of the plurality of blocks to store a checksum;formatting the storage device into the plurality of blocks; and duringthe formatting, writing the pattern into the set of bits within each ofthe plurality of blocks, wherein no checksum value is written to thechecksum field during the formatting; wherein the formatting comprisesexecuting of a SCSI FORMAT UNIT command, further comprising: setting aFMTDATA field in the FORMAT UNIT command field within data structures ofthe FORMAT UNIT command; setting an IP field in a DEFECT LIST HEADERfield within the data structures of the FORMAT UNIT command; setting aPATTERN TYPE to be hexadecimal 01 in an INITIALIZATION PATTERNDESCRIPTOR field within the data structures of the FORMAT UNIT command;and setting an INITIALIZATION PATTERN LENGTH and an INITIALIZATIONPATTERN field in the INITIALIZATION PATTERN DESCRIPTOR field within thedata structures of the FORMAT UNIT command.
 9. The article ofmanufacture of claim 8, where the checksum field occupies the samelocation as the set of bits within each of the plurality of plurality ofblocks.
 10. The article of manufacture of claim 8, wherein the patternand checksum field are at identical locations in each of the pluralityof blocks.
 11. The article of manufacture of claim 8, wherein the blocksize on the storage device is increased as a result of storing thechecksum.
 12. The article of manufacture of claim 8, wherein the SCSIFORMAT UNIT command is configured by a host system and executed by thestorage device.
 13. The article of manufacture of claim 8, wherein thestorage device is a member of a set of storage devices comprising aDirect Access Storage Device (DASD), Just a Bunch of Disks (JBOD), aRedundant Array of Independent Disks (RAID), a flexible disk, a rigiddisk, a tape library and an optical library.